HAL2 Migrator
HAL1 CRYP –> HAL2 CRYP ¶
The goal of this page is to show how to migrate the initialization sequence using STM32CubeMX2:
Open STM32CubeMX2 CRYP configuration panel.
Configure the SW layer HAL.
Configure the main CRYP features.
Configure the advanced CRYP features if needed.
Configure the CRYP DMA(s) if the application requires the CRYP to be used in DMA mode.
Configure the NVIC if the application requires the CRYP to be used in IT mode.
Generate the code.
HAL CRYP configuration panel ¶
Create a new project with the STM32CubeMX2, then start the initialization and the main configuration.
HAL CRYP main features configuration ¶
Configure the CRYP main features.
HAL CRYP advanced features configuration ¶
Configure the advanced CRYP features if needed.
DMA configuration ¶
Configure the CRYP DMA channels if the application requires to use the CRYP in DMA mode.
NVIC configuration ¶
Configure the NVIC in case of an interrupt.
Generated CRYP initialization and de-initialization sequences ¶
The CRYP initialization and de-initialization sequences are generated in the
mx_cryp_init
and
mx_cryp_deinit
functions in the
mx_cryp.c
file under
$YOUR_PROJECT_NAME$/$YOUR_PROJECT_NAME$_SW/generated/STM32Cube_CodeGen.
|
Topic |
HAL1 Code Snippet |
HAL2 Code Snippet |
|---|---|---|
|
Handle declaration |
CRYP_HandleTypeDef hcryp;
|
hal_cryp_handle_t hCRYP;
|
|
Initialization and configuration sequence |
void MX_CRYP_Init(void)
{
hcryp.Instance = CRYP;
hcryp.Init.DataType = CRYP_NO_SWAP;
hcryp.Init.KeySize = CRYP_KEYSIZE_128B;
hcryp.Init.pKey = (uint32_t *)pKeyCRYP;
hcryp.Init.pInitVect = (uint32_t *)pInitVectCRYP;
hcryp.Init.Algorithm = CRYP_AES_GCM;
hcryp.Init.Header = (uint32_t *)HeaderCRYP;
hcryp.Init.HeaderSize = 1;
hcryp.Init.DataWidthUnit = CRYP_DATAWIDTHUNIT_WORD;
hcryp.Init.HeaderWidthUnit = CRYP_HEADERWIDTHUNIT_WORD;
hcryp.Init.KeyIVConfigSkip = CRYP_KEYIVCONFIG_ALWAYS;
hcryp.Init.KeyMode = CRYP_KEYMODE_NORMAL;
if (HAL_CRYP_Init(&hcryp) != HAL_OK)
{
Error_Handler();
}
}
void HAL_CRYP_MspInit(CRYP_HandleTypeDef* crypHandle)
{
if(crypHandle->Instance==CRYP)
{
__HAL_RCC_CRYP_CLK_ENABLE();
HAL_NVIC_SetPriority(CRYP_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(CRYP_IRQn);
}
}
void MX_LPDMA1_Init(void)
{
__HAL_RCC_LPDMA1_CLK_ENABLE();
handle_LPDMA1_Channel0.Instance = LPDMA1_Channel0;
handle_LPDMA1_Channel0.Init.Request = DMA_PERIPH_TO_MEMORY;
handle_LPDMA1_Channel0.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
handle_LPDMA1_Channel0.Init.Direction = DMA_PERIPH_TO_MEMORY;
handle_LPDMA1_Channel0.Init.SrcInc = DMA_SINC_FIXED;
handle_LPDMA1_Channel0.Init.DestInc = DMA_DINC_FIXED;
handle_LPDMA1_Channel0.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_BYTE;
handle_LPDMA1_Channel0.Init.DestDataWidth = DMA_DEST_DATAWIDTH_BYTE;
handle_LPDMA1_Channel0.Init.Priority = DMA_LOW_PRIORITY_LOW_WEIGHT;
handle_LPDMA1_Channel0.Init.SrcBurstLength = 1;
handle_LPDMA1_Channel0.Init.DestBurstLength = 1;
handle_LPDMA1_Channel0.Init.TransferAllocatedPort =
DMA_SRC_ALLOCATED_PORT0|DMA_DEST_ALLOCATED_PORT0;
handle_LPDMA1_Channel0.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;
handle_LPDMA1_Channel0.Init.Mode = DMA_NORMAL;
if (HAL_DMA_Init(&handle_LPDMA1_Channel0) != HAL_OK)
{
Error_Handler();
}
if (HAL_DMA_ConfigChannelAttributes(&handle_LPDMA1_Channel0,
DMA_CHANNEL_NPRIV) != HAL_OK)
{
Error_Handler();
}
}
void MX_LPDMA2_Init(void)
{
__HAL_RCC_LPDMA2_CLK_ENABLE();
handle_LPDMA2_Channel0.Instance = LPDMA2_Channel0;
handle_LPDMA2_Channel0.Init.Request = DMA_MEMORY_TO_PERIPH;
handle_LPDMA2_Channel0.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
handle_LPDMA2_Channel0.Init.Direction = DMA_MEMORY_TO_PERIPH;
handle_LPDMA2_Channel0.Init.SrcInc = DMA_SINC_FIXED;
handle_LPDMA2_Channel0.Init.DestInc = DMA_DINC_FIXED;
handle_LPDMA2_Channel0.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_BYTE;
handle_LPDMA2_Channel0.Init.DestDataWidth = DMA_DEST_DATAWIDTH_BYTE;
handle_LPDMA2_Channel0.Init.Priority = DMA_LOW_PRIORITY_LOW_WEIGHT;
handle_LPDMA2_Channel0.Init.SrcBurstLength = 1;
handle_LPDMA2_Channel0.Init.DestBurstLength = 1;
handle_LPDMA2_Channel0.Init.TransferAllocatedPort =
DMA_SRC_ALLOCATED_PORT0|DMA_DEST_ALLOCATED_PORT0;
handle_LPDMA2_Channel0.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;
handle_LPDMA2_Channel0.Init.Mode = DMA_NORMAL;
if (HAL_DMA_Init(&handle_LPDMA2_Channel0) != HAL_OK)
{
Error_Handler();
}
if (HAL_DMA_ConfigChannelAttributes(&handle_LPDMA2_Channel0,
DMA_CHANNEL_NPRIV) != HAL_OK)
{
Error_Handler();
}
}
|
hal_cryp_handle_t *mx_cryp_init(void)
{
if (HAL_CRYP_Init(&hCRYP, HAL_CRYP) != HAL_OK)
{
return NULL;
}
HAL_RCC_CRYP_EnableClock();
HAL_CRYP_AES_ECB_SetConfig(&hCRYP);
HAL_CRYP_SetDataSwapping(&hCRYP, HAL_CRYP_DATA_SWAPPING_NO);
/* Configure the DMA OUT */
HAL_RCC_GPDMA1_EnableClock();
if (HAL_DMA_Init(&hGPDMA1_CH1, HAL_GPDMA1_CH1) != HAL_OK)
{
return NULL;
}
hal_dma_direct_xfer_config_t xfer_cfg_cryp_out_dma;
xfer_cfg_cryp_out_dma.request = HAL_GPDMA1_REQUEST_CRYP_OUT;
xfer_cfg_cryp_out_dma.direction = HAL_DMA_DIRECTION_PERIPH_TO_MEMORY;
xfer_cfg_cryp_out_dma.src_inc = HAL_DMA_SRC_ADDR_FIXED;
xfer_cfg_cryp_out_dma.dest_inc = HAL_DMA_DEST_ADDR_INCREMENTED;
xfer_cfg_cryp_out_dma.src_data_width = HAL_DMA_SRC_DATA_WIDTH_WORD;
xfer_cfg_cryp_out_dma.dest_data_width = HAL_DMA_DEST_DATA_WIDTH_WORD;
xfer_cfg_cryp_out_dma.priority = HAL_DMA_PRIORITY_LOW_WEIGHT_LOW;
if (HAL_DMA_SetConfigPeriphDirectXfer(&hGPDMA1_CH1, &xfer_cfg_cryp_out_dma) != HAL_OK)
{
return NULL;
}
/* Enable the interruption for GPDMA1_CH1 */
HAL_CORTEX_NVIC_SetPriority(GPDMA1_CH1_IRQn, HAL_CORTEX_NVIC_PREEMP_PRIORITY_0, HAL_CORTEX_NVIC_SUB_PRIORITY_0);
HAL_CORTEX_NVIC_EnableIRQ(GPDMA1_CH1_IRQn);
/* Link the Output DMA handle to the CRYP handle */
if (HAL_CRYP_SetOutDMA(&hCRYP, &hGPDMA1_CH1) != HAL_OK)
{
return NULL;
}
/* Configure the DMA IN */
HAL_RCC_GPDMA1_EnableClock();
if (HAL_DMA_Init(&hGPDMA1_CH0, HAL_GPDMA1_CH0) != HAL_OK)
{
return NULL;
}
hal_dma_direct_xfer_config_t xfer_cfg_cryp_in_dma;
xfer_cfg_cryp_in_dma.request = HAL_GPDMA1_REQUEST_CRYP_IN;
xfer_cfg_cryp_in_dma.direction = HAL_DMA_DIRECTION_MEMORY_TO_PERIPH;
xfer_cfg_cryp_in_dma.src_inc = HAL_DMA_SRC_ADDR_INCREMENTED;
xfer_cfg_cryp_in_dma.dest_inc = HAL_DMA_DEST_ADDR_FIXED;
xfer_cfg_cryp_in_dma.src_data_width = HAL_DMA_SRC_DATA_WIDTH_WORD;
xfer_cfg_cryp_in_dma.dest_data_width = HAL_DMA_DEST_DATA_WIDTH_WORD;
xfer_cfg_cryp_in_dma.priority = HAL_DMA_PRIORITY_LOW_WEIGHT_LOW;
if (HAL_DMA_SetConfigPeriphDirectXfer(&hGPDMA1_CH0, &xfer_cfg_cryp_in_dma) != HAL_OK)
{
return NULL;
}
/* Enable the interruption for GPDMA1_CH0 */
HAL_CORTEX_NVIC_SetPriority(GPDMA1_CH0_IRQn, HAL_CORTEX_NVIC_PREEMP_PRIORITY_0, HAL_CORTEX_NVIC_SUB_PRIORITY_0);
HAL_CORTEX_NVIC_EnableIRQ(GPDMA1_CH0_IRQn);
/* Link the Input DMA handle to the CRYP handle */
if (HAL_CRYP_SetInDMA(&hCRYP, &hGPDMA1_CH0) != HAL_OK)
{
return NULL;
}
/* Enable the interruption for CRYP */
HAL_CORTEX_NVIC_SetPriority(CRYP_IRQn, HAL_CORTEX_NVIC_PREEMP_PRIORITY_0, HAL_CORTEX_NVIC_SUB_PRIORITY_0);
HAL_CORTEX_NVIC_EnableIRQ(CRYP_IRQn);
return &hCRYP;
}
|
|
Deinitialization sequence |
void MX_CRYP_DeInit(void)
{
if (HAL_CRYP_DeInit(&hcryp) != HAL_OK)
{
Error_Handler();
}
}
void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef* crypHandle)
{
if(crypHandle->Instance==CRYP)
{
__HAL_RCC_CRYP_CLK_DISABLE();
HAL_NVIC_DisableIRQ(CRYP_IRQn);
}
}
|
void mx_cryp_deinit(void)
{
/* Disable the interruption for CRYP */
HAL_CORTEX_NVIC_DisableIRQ(CRYP_IRQn);
(void)HAL_CRYP_DeInit(&hCRYP);
HAL_RCC_CRYP_Reset();
HAL_RCC_CRYP_DisableClock();
/* De-initialize the DMA channel */
HAL_DMA_DeInit(&hGPDMA1_CH1);
/* Disable the interruption for DMA */
HAL_CORTEX_NVIC_DisableIRQ(GPDMA1_CH1_IRQn);
/* De-initialize the DMA channel */
HAL_DMA_DeInit(&hGPDMA1_CH0);
/* Disable the interruption for DMA */
HAL_CORTEX_NVIC_DisableIRQ(GPDMA1_CH0_IRQn);
}
|
|
IRQ handle function |
void CRYP_IRQHandler(void)
{
HAL_CRYP_IRQHandler(&hcryp);
}
|
void CRYP_IRQHandler(void)
{
HAL_CRYP_IRQHandler(&hCRYP);
}
|